package com.itheima.leetcode.od.b.sort;

import java.util.Arrays;

/**
 * (B卷,100分)- 矩形相交的面积（Java & JS & Python & C）
 * <p>
 * 题目描述
 * <p>
 * 给出3组点坐标(x, y, w, h)，-1000<x,y<1000，w,h为正整数。
 * <p>
 * (x, y, w, h)表示平面直角坐标系中的一个矩形：
 * <p>
 * x, y为矩形左上角坐标点，w, h向右w，向下h。
 * <p>
 * (x, y, w, h)表示x轴(x, x+w)和y轴(y, y-h)围成的矩形区域；
 * <p>
 * (0, 0, 2, 2)表示 x轴(0, 2)和y 轴(0, -2)围成的矩形区域；
 * <p>
 * (3, 5, 4, 6)表示x轴(3, 7)和y轴(5, -1)围成的矩形区域；
 * <p>
 * 求3组坐标构成的矩形区域重合部分的面积。
 * <p>
 * 输入描述
 * <p>
 * 3行输入分别为3个矩形的位置，分别代表“左上角x坐标”，“左上角y坐标”，“矩形宽”，“矩形高” -1000 <= x,y < 1000
 * <p>
 * 输出描述
 * <p>
 * 输出3个矩形相交的面积，不相交的输出0。
 */
public class RectanglesIntersectArea {
    public static void main(String[] args) {
        /*Scanner in = new Scanner(System.in);

        // 找出所有矩形覆盖的最大范围
        int minX = Integer.MAX_VALUE, maxX = Integer.MIN_VALUE;
        int minY = Integer.MAX_VALUE, maxY = Integer.MIN_VALUE;
        int[][] rectangles = new int[3][4];

        // 读取输入并找出边界
        for (int i = 0; i < 3; i++) {
            int x = in.nextInt();
            int y = in.nextInt();
            int w = in.nextInt();
            int h = in.nextInt();
            rectangles[i] = new int[]{x, y, w, h};

            minX = Math.min(minX, x);
            maxX = Math.max(maxX, x + w);
            minY = Math.min(minY, y - h);
            maxY = Math.max(maxY, y);
        }*/

        String input = "1, 6, 4, 4\n3, 5, 3, 4\n0, 3, 7, 3";
        int[][] rectangles = Arrays.stream(input.split("\n"))
                .map(s -> Arrays.stream(s.split(", "))
                        .mapToInt(Integer::parseInt)
                        .toArray())
                .toArray(int[][]::new);

        System.out.println(getResult(rectangles));
    }

    private static int getResult(int[][] rectangles) {
        int wid = Arrays.stream(new int[]{rectangles[0][0] + rectangles[0][2], rectangles[1][0] + rectangles[1][2],
                        rectangles[2][0] + rectangles[2][2]})
                .min().getAsInt()
                - Arrays.stream(new int[]{rectangles[0][0], rectangles[1][0],
                        rectangles[2][0]})
                .max().getAsInt();
        if (wid <= 0) {
            return 0;
        }

        int hei = Arrays.stream(new int[]{rectangles[0][1], rectangles[1][1],
                rectangles[2][1]}).min().getAsInt()
                - Arrays.stream(new int[]{rectangles[0][1] - rectangles[0][3], rectangles[1][1] - rectangles[1][3],
                rectangles[2][1] - rectangles[2][3]}).max().getAsInt();
        if (hei <= 0) {
            return 0;
        }

        return wid * hei;
    }
}
